// pages/ledger/ledger.js
const FS = wx.getFileSystemManager()
const WXfilePath = wx.env.USER_DATA_PATH
const FILETYPE = ".json"
const isOpenConsole = false // true 开启console  false 关闭

var fileList = [] // 根目录
var monthFileList = [] // 本月文件目录
var tableData = []
// 入账
export function insertDataJS(purpose, money, author, authorLabel) {
	insertData(purpose, money, author, authorLabel)
}
// 获取今日账单
export function getTodayDataJS(file, month) {
	let filePath = file ? `${getTodayFilePath(month).dirName}/${file}` : null
	return Promise.resolve(getFileData(filePath))
}
// 获取本月账单
export function getMonthFileListJS(fileMonth) {
	return Promise.resolve(getMonthFileList(fileMonth))
}
// 统计本月账单
export function sumMonthFileJS(fileMonth) {
	return Promise.resolve(sumMonthFile(fileMonth))
}
// 分享本月账单
export function shareMonthFileJS(fileMonth) {
	shareMonthFile(fileMonth)
}
// 删除当日指定条数据
export function removeDayItemDataJS(item, fileMonth, fileName) {
	return Promise.resolve(removeDayItemData(item, fileMonth, fileName))
}
// 删除指定日文件
export function removeFileJS(fileName) {
	let dirData = getTodayFilePath()
	removeFile(dirData.dirName + "/" + fileName)
}
// 删除指定文件目录
export function removeFileDirStorageJS() {
	removeFileDirStorage()
}
// 页面测试按钮点击事件
// createFileTest() {
// 		this.createFile(this.getTodayFilePath().filePath)
// 	},
// 	insertDataTest() {
// 		this.insertData("抽烟测试写入", 17, "小李同学")
// 	},
// 	removeFileTest() {
// 		this.removeFile(this.getTodayFilePath().filePath)
// 	},
// 	removeDirTest() {
// 		this.removeDir(this.getTodayFilePath().dirName)
// 	},
// 	getFileDataTest() {
// 		this.getFileData()
// 	},

// 文件内数据操作
// 文件内数据操作
// 文件内数据操作
// 文件内数据操作
// 文件内数据操作
// 文件内数据操作

/**
 * 删除当前日，指定数据
 * @param {*} itemParam 
 * @param {*} filePath 
 */
function removeDayItemData(itemParam, fileMonth, fileDayFileName) {
	console.log("删除当前日，指定数据", itemParam, fileMonth, fileDayFileName)
	let dirData = getTodayFilePath()
	let filePath = dirData.filePath
	if (fileMonth) {
		dirData = getTodayFilePath(fileMonth, fileDayFileName)
		filePath = dirData.filePath
	}

	return new Promise((resolve, reject) => {
		wx.showModal({
			title: '删除提示',
			content: `请确认是否删除${itemParam.datetime}${itemParam.authorLabel}消费${itemParam.money}元记录`,
			complete: (resModal) => {
				if (resModal.cancel) {
					reject("取消删除")
				}

				if (resModal.confirm) {
					// 判断文件/目录是否存在
					FS.access({
						path: filePath,
						success(res) {
							// 文件数据，先删后插
							removeFile(filePath).then(clearRes => {
								if (!clearRes || typeof JSON.parse(clearRes) != "object") {
									clearRes = JSON.stringify([])
								}
								let writeDataCopy = JSON.parse(clearRes)
								writeDataCopy = writeDataCopy.filter(itemF => {
									if (itemF.id !== itemParam.id) {
										return itemF
									}
								})

								let writeResultDataCopy = JSON.stringify(writeDataCopy)
								console.log("正在准备追加数据", writeResultDataCopy)
								// createFile(filePath, writeResultDataCopy)
								FS.writeFile({
									filePath: filePath,
									data: writeResultDataCopy,
									encoding: 'utf8',
									success() {
										wx.showToast({
											title: '移除完成',
											icon: "none"
										})
										resolve()
									},
									fail() {
										wx.showToast({
											title: '移除失败',
											icon: "none"
										})
										reject()
									}
								})
							})
						},
						fail(err) {}
					})
				}
			}
		})

	})
}

function insertData(purpose, money, author, authorLabel) {
	let todayFilePath = getTodayFilePath()
	// 本次插入数据
	let writeData = {
		id: todayFilePath.timestamp,
		datetime: todayFilePath.datetime,
		time: todayFilePath.time,
		purpose: purpose,
		money: money,
		author: author,
		authorLabel
	}
	if (!purpose) {
		return wx.showToast({
			title: "干啥花的钱写上",
			icon: "none"
		})
	}
	if (money < 0) {
		return wx.showToast({
			title: "元子咋还填负了呢",
			icon: "none"
		})
	}
	if (!author) {
		return wx.showToast({
			title: "支出人选了嘛",
			icon: "none"
		})
	}
	tableData.push(writeData)
	let writeResultData = JSON.stringify(tableData)
	console.log("正在准备插入数据", writeResultData)
	// 判断文件/目录是否存在
	FS.access({
		path: todayFilePath.filePath,
		success(res) {
			console.log("今日文件已创建", res)
			// 文件数据，先删后插
			removeFile(todayFilePath.filePath).then(clearRes => {
				if (!clearRes || typeof JSON.parse(clearRes) != "object") {
					clearRes = JSON.stringify([])
				}
				let writeDataCopy = JSON.parse(clearRes)
				writeDataCopy.push(writeData)
				let writeResultDataCopy = JSON.stringify(writeDataCopy)
				console.log("正在准备追加数据", writeResultDataCopy)
				createFile(todayFilePath.filePath, writeResultDataCopy)
			})
		},
		fail(err) {
			console.log("今日文件未创建", err)
			createFile(todayFilePath.filePath, writeResultData)
		}
	})
}

// 获取指定文件内数据
function getFileData(filePath) {
	return new Promise((resolve, reject) => {
		filePath = !filePath ? getTodayFilePath().filePath : filePath
		// 判断文件/目录是否存在
		console.log("查看是否存在文件", filePath)
		FS.access({
			path: filePath,
			success(res) {
				console.log("获取指定文件内数据-今日文件已创建", res)
				let fileData = FS.readFileSync(filePath, 'utf8')
				if (!fileData) {
					reject({
						msg: `文件：${filePath},暂无数据！`,
						data: []
					})
					return wx.showToast({
						title: `文件：${filePath},暂无数据！`,
						icon: "none",
						duration: 5000
					})
				}
				try {
					tableData = JSON.parse(fileData)
					console.warn(`查看${filePath}文件内信息`, tableData)
					isOpenConsole ? console.table(tableData) : ""
					resolve({
						msg: `操作成功！`,
						data: tableData
					})
				} catch (e) {
					//TODO handle the exception
					console.error(`${filePath}文件JSON串格式解析失败`, fileData ? fileData : "文件内无数据")
					reject({
						msg: `${filePath}文件JSON串格式解析失败`,
						data: []
					})
				}
			},
			fail(err) {
				if (err && err.errMsg.indexOf("fail no such file or directory")) {
					console.log("获取指定文件内数据-今日文件未创建", err)
					// insertData("机器操作-零元购", 0, "机器小李")
					reject({
						msg: `今日文件未创建`,
						data: []
					})
				} else {
					console.error("获取指定文件内数据-getFileData-err", err)
					reject({
						msg: `getFileData-err,获取失败`,
						data: []
					})
				}
			},
			complete(com) {
				wx.hideLoading()
			}
		})
	})
}








// 文件操作
// 文件操作
// 文件操作
// 文件操作
// 文件操作

// 获取今日文件名称
function getTodayFilePath(custormMonth, custormDay) {
	let result = ""
	let now = new Date();
	let year = now.getFullYear(); // 年
	let month = (now.getMonth() + 1).toString().padStart(2, '0'); // 月，注意getMonth()是从0开始的
	let date = now.getDate().toString().padStart(2, '0'); // 日
	let hours = now.getHours().toString().padStart(2, '0'); // 时
	let minutes = now.getMinutes().toString().padStart(2, '0'); // 分
	let seconds = now.getSeconds().toString().padStart(2, '0'); // 秒
	let timestamp = now.getTime();
	let yearMonth = `${custormMonth?custormMonth:year+"-"+month}`
	let yearMonthDayFileName = custormDay ? custormDay : `${year}-${month}-${date}${FILETYPE}`
	result = `${WXfilePath}/${yearMonth}/${yearMonthDayFileName}`
	return {
		filePath: result, // 文件路径
		dirName: `${WXfilePath}/${yearMonth}`, // 文件目录
		dateMonth: `${yearMonth}`, // 当前月份
		datetime: `${year}-${month}-${date} ${hours}:${minutes}:${seconds}`, // 操作日期时间
		timestamp: timestamp, // 操作时间戳
		time: `${hours}:${minutes}:${seconds}`, // 操作时间
	}
}
// 创建文件
function createFile(filePath, jsonData) {
	if (!filePath) {
		return
	}

	FS.access({
		path: filePath,
		success(res) {
			wx.showToast({
				title: "文件已存在，无需重复创建",
				icon: "none"
			})
		},
		fail(err) {
			FS.writeFile({
				filePath: filePath,
				data: jsonData,
				encoding: 'utf8',
				success(res) {
					console.log("文件创建成功", res)
					getFileList()
					wx.showToast({
						title: '入账完成了呦，团团爱你呦',
						icon: "none",
						duration: 5000
					})
				},
				fail(err) {
					console.error("文件创建失败,准备创建本月目录文件夹", err)
					FS.mkdir({
						dirPath: getTodayFilePath().dirName,
						recursive: false,
						success(dirRes) {
							console.log("本月目录创建成功，正在自动重新创建文件", dirRes)
							createFile(filePath, jsonData)
						},
						fail(dirErr) {
							console.error("本月目录创建失败，原因如下1", dirErr)
							console.error("本月目录创建失败，原因如下2", filePath, jsonData)

							wx.showToast({
								title: "文件管理服务错误，请联系你老公尽快解决呦",
								icon: "none",
								duration: 5000
							})
						}
					})
				}
			})
		}
	})
}

// 删除文件
async function removeFile(filePath) {
	return await new Promise((resolve, reject) => {
		if (!filePath) {
			reject()
		}

		console.warn("正在准备删除文件", filePath)
		// 判断文件/目录是否存在
		FS.access({
			path: filePath.toString(),
			success(res) {
				// 文件存在=读取文件内数据
				let filePathData = FS.readFileSync(filePath, 'utf8')
				// 数据读取后=删除此文件
				FS.unlink({
					filePath,
					success: (res) => {
						console.log("文件删除成功", res)
						getFileList()
						resolve(filePathData)
					},
					fail: err => {
						console.error(`文件${filePath}删除失败`, err)
						wx.showToast({
							title: "文件删除失败",
							icon: "none"
						})
						reject()
					}
				})
			},
			fail(err) {
				// 文件不存在或其他错误
				console.error("文件目录还不存在的呦", err)
				// wx.showToast({
				// 	title: "文件目录还不存在的呦",
				// 	icon: "none"
				// })
				resolve()
			}
		})
	})
}

// 删除指定月份数据目录
function removeFileDirStorage() {
	let fs_fileList = FS.readdirSync(wx.env.USER_DATA_PATH)
	if (fs_fileList.length <= 0) {
		return wx.showToast({
			title: '暂无文件目录信息',
			icon: "none"
		})
	}
	wx.showActionSheet({
		itemList: fs_fileList,
		success: (res) => {
			removeDir(getTodayFilePath(fs_fileList[res.tapIndex]).dirName)
		}
	})
}
// 删除文件目录
function removeDir(dirPath) {
	if (!dirPath) {
		return
	}
	if (dirPath == WXfilePath) {
		return console.error(WXfilePath, "文件目录不可以删除")
	}
	console.warn("正在准备删除目录", dirPath)
	// 判断文件/目录是否存在
	FS.access({
		path: dirPath.toString(),
		success(res) {
			// 目录存在
			FS.rmdir({
				dirPath: dirPath.toString(),
				recursive: true,
				success: dirRes => {
					console.log(`${dirPath}文件夹删除成功`, dirRes)
				},
				fail: err => {
					console.error(`${dirPath}文件夹删除失败`, err)
				}
			})
		},
		fail(err) {
			// 文件不存在或其他错误
			console.error("文件目录还不存在的呦", err)
			wx.showToast({
				title: "文件目录还不存在的呦",
				icon: "none"
			})
		}
	})
}

// 获取已存在的小程序根目录文件列表
export async function getFileList() {
	let result = await FS.readdirSync(wx.env.USER_DATA_PATH);
	console.warn("查看文件列表", result)
	isOpenConsole ? console.table(result) : ""
	fileList = result || []
	return result
}
// 获取已存在的文件列表
function getMonthFileList(fileMonth) {
	if (!fileMonth) {
		fileMonth = getTodayFilePath().dateMonth
	}
	return new Promise((resolve, reject) => {
		// let fileMonth = getTodayFilePath().dateMonth
		let dirPath = WXfilePath + "/" + fileMonth

		FS.access({
			path: dirPath.toString(),
			success(res) {
				// 目录存在
				let result = FS.readdirSync(dirPath)
				console.warn(`查看${dirPath}文件列表`, result)
				isOpenConsole ? console.table(result) : ""
				if (monthFileList) {
					monthFileList = result
				} else {
					var monthFileList = result;
				}
				resolve(result)
			},
			fail(err) {
				// 文件不存在或其他错误
				console.error("getMonthFileList-文件目录还不存在的呦", err)
				wx.showToast({
					title: "本月还没有开始记录呦",
					icon: "none"
				})
				monthFileList = []
				reject(monthFileList)
			}
		})
	})
}

// 统计分享本月账单
function sumMonthFile(fileMonth) {
	return new Promise(async (resolve, reject) => {
		let dirData = null;
		if (fileMonth) {
			dirData = getTodayFilePath(fileMonth)
		} else {
			dirData = getTodayFilePath()
		}
		console.log("是否指定统计分享月份账单", dirData)
		let downFileList = FS.readdirSync(dirData.dirName) // 本月文件目录下所有文件列表
		let nowMonthTotalDataFileName = dirData.dateMonth + "-合计" + FILETYPE // 月份合计

		// 剔除原合计文件
		try {
			downFileList = downFileList.filter(item => item.indexOf("合计") == -1)
			console.log("准备同步删除旧合计文件")
			await removeFile(dirData.dirName + "/" + nowMonthTotalDataFileName)
		} catch (error) {
			console.log("剔除原合计文件", error)
		}
		console.log("同步删除旧合计文件完成")


		// wx.showModal({
		// 	title: "谨慎操作！",
		// 	content: `请确认是否要对${dirData.dateMonth}月份的账单进行统计！`,
		// 	success: function (res) {
		// 		if (res.confirm) {

		// 		} else if (res.cancel) {
		// 			console.log('用户点击取消');
		// 		}
		// 	}
		// })

		// 统计本月所有数据
		let nowMonthTotalData = []
		wx.showLoading({
			title: "正在统计...",
		})
		try {
			// 无文件可提取
			if (downFileList.length <= 0) {
				wx.showToast({
					title: "还没有开始记账哝，保持住好习惯",
					icon: "none",
					duration: 5000
				})
				wx.hideLoading()
				reject("还没有开始记账哝，保持住好习惯")
			}
			downFileList.forEach((fileName, fileIndex) => {
				console.log("正在读取文件...", fileName, fileIndex)
				// 读取每日文件数据
				try {
					// 同步接口
					let nowData = FS.readFileSync(`${dirData.dirName}/${fileName}`, 'utf8', 0);

					let dayName = fileName.split(".")[0]
					nowData = nowData ? JSON.parse(nowData) : nowData
					let totalMoney = 0
					console.log("nowDatanowDatanowData", nowData)
					nowData.forEach(item => {
						totalMoney = Number(item.money) + totalMoney
					})
					nowMonthTotalData.push({
						[dayName]: nowData,
						totalMoney: totalMoney, // 今日总计
					})
					console.log(`${dayName}文件数据提取完成`, fileIndex,
						downFileList.length - 1, nowMonthTotalData)
					// 数据提取完成
					if (fileIndex >= downFileList.length - 1) {
						FS.writeFile({
							filePath: dirData.dirName + "/" + nowMonthTotalDataFileName,
							data: JSON.stringify(nowMonthTotalData),
							encoding: 'utf8',
							success(writeRes) {
								console.log(nowMonthTotalDataFileName + "月份统计文件创建成功", writeRes)
								wx.hideLoading()
								resolve(nowMonthTotalDataFileName)
							},
							fail(writeErr) {
								console.error("本月数据统计失败", writeErr)
								wx.hideLoading()
								wx.showToast({
									title: "本月数据统计失败，快请小李同学！",
									icon: "none",
									duration: 5000
								})
								reject("本月数据统计失败")
							}
						})
					}
				} catch (nowErr) {
					console.error(`shareMonthFile-showModal-readFile==${fileName}`, nowErr)
					wx.hideLoading()
					wx.showToast({
						title: `${fileName}文件提取失败`,
						iicon: "none"
					})
					reject(`${fileName}文件提取失败`)
				}
				// FS.readFile({
				// 	filePath: dirData.dirName + "/" + fileName,
				// 	encoding: 'utf8',
				// 	position: 0,
				// 	success(nowData) {
				// 		let dayName = fileName.split(".")[0]
				// 		nowData = nowData.data ? JSON.parse(nowData.data) : nowData.data
				// 		let totalMoney = 0
				// 		nowData.forEach(item => {
				// 			totalMoney = Number(item.money) + totalMoney
				// 		})
				// 		nowMonthTotalData.push({
				// 			[dayName]: nowData,
				// 			totalMoney: totalMoney, // 今日总计
				// 		})
				// 		console.log(`${dayName}文件数据提取完成`, fileIndex,
				// 			downFileList.length - 1, nowMonthTotalData)
				// 		// 数据提取完成
				// 		if (fileIndex >= downFileList.length - 1) {
				// 			FS.writeFile({
				// 				filePath: dirData.dirName + "/" + nowMonthTotalDataFileName,
				// 				data: JSON.stringify(nowMonthTotalData),
				// 				encoding: 'utf8',
				// 				success(writeRes) {
				// 					console.log(nowMonthTotalDataFileName + "月份统计文件创建成功", writeRes)
				// 					wx.hideLoading()
				// 					resolve()
				// 				},
				// 				fail(writeErr) {
				// 					console.error("本月数据统计失败", writeErr)
				// 					wx.hideLoading()
				// 					wx.showToast({
				// 						title: "本月数据统计失败，快请小李同学！",
				// 						icon: "none",
				// 						duration: 5000
				// 					})
				// 					reject("本月数据统计失败")
				// 				}
				// 			})
				// 		}
				// 	},
				// 	fail(nowErr) {
				// 		console.error(`shareMonthFile-showModal-readFile==${fileName}`, nowErr)
				// 		wx.hideLoading()
				// 		wx.showToast({
				// 			title: `${fileName}文件提取失败`,
				// 			iicon: "none"
				// 		})
				// 		reject(`${fileName}文件提取失败`)
				// 	}
				// })
			})
		} catch (tryCatchErr) {
			//TODO handle the exception
			wx.hideLoading()
			console.error("查看捕获到的统计错误", tryCatchErr)
			reject("查看捕获到的统计错误")
		}
	})
}
/**
 * 分享指定月文件
 * @param {*} fileMonth 
 */
function shareMonthFile(fileMonth) {
	let dirData = getTodayFilePath()
	if (fileMonth) {
		dirData = getTodayFilePath(fileMonth)
	}
	console.log("是否指定分享月份账单", dirData)

	let nowMonthTotalDataFileName = dirData.dateMonth + "-合计" + FILETYPE // 月份合计
	wx.showModal({
		title: "团团爱妈妈！",
		content: "团团：现在就要分享出本月账单嘛",
		success(shareRes) {
			if (shareRes.confirm) {
				getFileList()
				wx.shareFileMessage({
					filePath: dirData.dirName + "/" + nowMonthTotalDataFileName,
					fileName: nowMonthTotalDataFileName,
					success: () => {
						console.log('分享文件成功');
						wx.showToast({
							title: "已完成分享哝！快去跟他吐槽吧。",
							icon: "none",
							duration: 5000
						})
					},
					fail: (shareErr) => {
						console.log('分享文件失败', shareErr);
						if (shareErr.errMsg && shareErr.errMsg.indexOf("fail canceled")) {
							wx.showToast({
								title: '咋还取消分享了呢',
								icon: "none"
							})
						} else {
							wx.showToast({
								title: "CPU要着火啦，快联系小李同学灭火",
								icon: "none",
								duration: 5000
							})
						}
					}
				});
			} else if (shareRes.cancel) {
				console.log('用户点击取消');
			}
		}
	})
}